home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / controls / SWFLoader.as < prev    next >
Text File  |  2014-03-27  |  31KB  |  969 lines
  1. package mx.controls
  2. {
  3.    import flash.display.Bitmap;
  4.    import flash.display.DisplayObject;
  5.    import flash.display.DisplayObjectContainer;
  6.    import flash.display.Loader;
  7.    import flash.display.LoaderInfo;
  8.    import flash.events.Event;
  9.    import flash.events.HTTPStatusEvent;
  10.    import flash.events.IOErrorEvent;
  11.    import flash.events.ProgressEvent;
  12.    import flash.events.SecurityErrorEvent;
  13.    import flash.geom.Rectangle;
  14.    import flash.net.URLRequest;
  15.    import flash.system.ApplicationDomain;
  16.    import flash.system.Capabilities;
  17.    import flash.system.LoaderContext;
  18.    import flash.system.SecurityDomain;
  19.    import flash.utils.ByteArray;
  20.    import mx.core.Application;
  21.    import mx.core.FlexLoader;
  22.    import mx.core.FlexVersion;
  23.    import mx.core.IFlexDisplayObject;
  24.    import mx.core.IUIComponent;
  25.    import mx.core.UIComponent;
  26.    import mx.core.mx_internal;
  27.    import mx.events.FlexEvent;
  28.    import mx.managers.CursorManager;
  29.    import mx.managers.ISystemManager;
  30.    import mx.managers.SystemManagerGlobals;
  31.    import mx.styles.ISimpleStyleClient;
  32.    import mx.utils.LoaderUtil;
  33.    
  34.    use namespace mx_internal;
  35.    
  36.    public class SWFLoader extends UIComponent
  37.    {
  38.       
  39.       mx_internal static const VERSION:String = "3.0.0.0";
  40.        
  41.       
  42.       mx_internal var contentHolder:DisplayObject;
  43.       
  44.       private var brokenImage:Boolean = false;
  45.       
  46.       private var _bytesLoaded:Number = NaN;
  47.       
  48.       private var _autoLoad:Boolean = true;
  49.       
  50.       private var _loaderContext:LoaderContext;
  51.       
  52.       private var requestedURL:URLRequest;
  53.       
  54.       private var _showBusyCursor:Boolean = false;
  55.       
  56.       private var _scaleContent:Boolean = true;
  57.       
  58.       private var _bytesTotal:Number = NaN;
  59.       
  60.       private var flexContent:Boolean = false;
  61.       
  62.       private var explicitLoaderContext:Boolean = false;
  63.       
  64.       private var _maintainAspectRatio:Boolean = true;
  65.       
  66.       private var resizableContent:Boolean = false;
  67.       
  68.       private var brokenImageBorder:IFlexDisplayObject;
  69.       
  70.       private var isContentLoaded:Boolean = false;
  71.       
  72.       private var attemptingChildAppDomain:Boolean = false;
  73.       
  74.       private var _trustContent:Boolean = false;
  75.       
  76.       private var scaleContentChanged:Boolean = false;
  77.       
  78.       private var _source:Object;
  79.       
  80.       private var contentRequestID:String = null;
  81.       
  82.       private var contentChanged:Boolean = false;
  83.       
  84.       public function SWFLoader()
  85.       {
  86.          super();
  87.          tabChildren = true;
  88.          tabEnabled = false;
  89.          addEventListener(FlexEvent.INITIALIZE,initializeHandler);
  90.          showInAutomationHierarchy = false;
  91.       }
  92.       
  93.       [Bindable("trustContentChanged")]
  94.       public function get trustContent() : Boolean
  95.       {
  96.          return _trustContent;
  97.       }
  98.       
  99.       public function set trustContent(param1:Boolean) : void
  100.       {
  101.          if(_trustContent != param1)
  102.          {
  103.             _trustContent = param1;
  104.             invalidateProperties();
  105.             invalidateSize();
  106.             invalidateDisplayList();
  107.             dispatchEvent(new Event("trustContentChanged"));
  108.          }
  109.       }
  110.       
  111.       public function get contentHeight() : Number
  112.       {
  113.          return !!mx_internal::contentHolder ? Number(mx_internal::contentHolder.height) : Number(NaN);
  114.       }
  115.       
  116.       [Bindable("maintainAspectRatioChanged")]
  117.       public function get maintainAspectRatio() : Boolean
  118.       {
  119.          return _maintainAspectRatio;
  120.       }
  121.       
  122.       private function contentLoaderInfo_progressEventHandler(param1:ProgressEvent) : void
  123.       {
  124.          _bytesTotal = param1.bytesTotal;
  125.          _bytesLoaded = param1.bytesLoaded;
  126.          dispatchEvent(param1);
  127.       }
  128.       
  129.       private function contentLoaded() : void
  130.       {
  131.          var loaderInfo:LoaderInfo = null;
  132.          isContentLoaded = true;
  133.          if(mx_internal::contentHolder is Loader)
  134.          {
  135.             loaderInfo = Loader(mx_internal::contentHolder).contentLoaderInfo;
  136.          }
  137.          resizableContent = false;
  138.          if(loaderInfo)
  139.          {
  140.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  141.             {
  142.                resizableContent = true;
  143.             }
  144.             if(resizableContent)
  145.             {
  146.                try
  147.                {
  148.                   flexContent = Loader(mx_internal::contentHolder).content is IFlexDisplayObject;
  149.                }
  150.                catch(e:Error)
  151.                {
  152.                   flexContent = false;
  153.                }
  154.             }
  155.          }
  156.          try
  157.          {
  158.             if(tabChildren && mx_internal::contentHolder is Loader && Loader(mx_internal::contentHolder).content is DisplayObjectContainer)
  159.             {
  160.                Loader(mx_internal::contentHolder).tabChildren = true;
  161.                DisplayObjectContainer(Loader(mx_internal::contentHolder).content).tabChildren = true;
  162.             }
  163.          }
  164.          catch(e:Error)
  165.          {
  166.          }
  167.          invalidateSize();
  168.          invalidateDisplayList();
  169.       }
  170.       
  171.       override public function get baselinePosition() : Number
  172.       {
  173.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  174.          {
  175.             return 0;
  176.          }
  177.          return super.baselinePosition;
  178.       }
  179.       
  180.       private function unScaleContent() : void
  181.       {
  182.          mx_internal::contentHolder.scaleX = 1;
  183.          mx_internal::contentHolder.scaleY = 1;
  184.          mx_internal::contentHolder.x = 0;
  185.          mx_internal::contentHolder.y = 0;
  186.       }
  187.       
  188.       private function get contentHolderHeight() : Number
  189.       {
  190.          var loaderInfo:LoaderInfo = null;
  191.          var content:IFlexDisplayObject = null;
  192.          var testContent:DisplayObject = null;
  193.          if(mx_internal::contentHolder is Loader)
  194.          {
  195.             loaderInfo = Loader(mx_internal::contentHolder).contentLoaderInfo;
  196.          }
  197.          if(loaderInfo)
  198.          {
  199.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  200.             {
  201.                try
  202.                {
  203.                   content = Loader(mx_internal::contentHolder).content as IFlexDisplayObject;
  204.                   if(content)
  205.                   {
  206.                      return content.measuredHeight;
  207.                   }
  208.                }
  209.                catch(error:Error)
  210.                {
  211.                   return mx_internal::contentHolder.height;
  212.                }
  213.             }
  214.             else
  215.             {
  216.                try
  217.                {
  218.                   testContent = Loader(mx_internal::contentHolder).content;
  219.                }
  220.                catch(error:Error)
  221.                {
  222.                   return mx_internal::contentHolder.height;
  223.                }
  224.             }
  225.             return loaderInfo.height;
  226.          }
  227.          if(mx_internal::contentHolder is IUIComponent)
  228.          {
  229.             return IUIComponent(mx_internal::contentHolder).getExplicitOrMeasuredHeight();
  230.          }
  231.          if(mx_internal::contentHolder is IFlexDisplayObject)
  232.          {
  233.             return IFlexDisplayObject(mx_internal::contentHolder).measuredHeight;
  234.          }
  235.          return mx_internal::contentHolder.height;
  236.       }
  237.       
  238.       public function set maintainAspectRatio(param1:Boolean) : void
  239.       {
  240.          _maintainAspectRatio = param1;
  241.          dispatchEvent(new Event("maintainAspectRatioChanged"));
  242.       }
  243.       
  244.       public function set showBusyCursor(param1:Boolean) : void
  245.       {
  246.          if(_showBusyCursor != param1)
  247.          {
  248.             _showBusyCursor = param1;
  249.             if(_showBusyCursor)
  250.             {
  251.                CursorManager.registerToUseBusyCursor(this);
  252.             }
  253.             else
  254.             {
  255.                CursorManager.unRegisterToUseBusyCursor(this);
  256.             }
  257.          }
  258.       }
  259.       
  260.       [Bindable("complete")]
  261.       public function get bytesTotal() : Number
  262.       {
  263.          return _bytesTotal;
  264.       }
  265.       
  266.       private function initializeHandler(param1:FlexEvent) : void
  267.       {
  268.          if(contentChanged)
  269.          {
  270.             contentChanged = false;
  271.             if(_autoLoad)
  272.             {
  273.                load(_source);
  274.             }
  275.          }
  276.       }
  277.       
  278.       public function get showBusyCursor() : Boolean
  279.       {
  280.          return _showBusyCursor;
  281.       }
  282.       
  283.       public function set scaleContent(param1:Boolean) : void
  284.       {
  285.          if(_scaleContent != param1)
  286.          {
  287.             _scaleContent = param1;
  288.             scaleContentChanged = true;
  289.             invalidateDisplayList();
  290.          }
  291.          dispatchEvent(new Event("scaleContentChanged"));
  292.       }
  293.       
  294.       private function contentLoaderInfo_openEventHandler(param1:Event) : void
  295.       {
  296.          dispatchEvent(param1);
  297.       }
  298.       
  299.       override public function regenerateStyleCache(param1:Boolean) : void
  300.       {
  301.          var sm:ISystemManager = null;
  302.          var recursive:Boolean = param1;
  303.          super.regenerateStyleCache(recursive);
  304.          try
  305.          {
  306.             sm = content as ISystemManager;
  307.             if(sm != null)
  308.             {
  309.                Object(sm).regenerateStyleCache(recursive);
  310.             }
  311.          }
  312.          catch(error:Error)
  313.          {
  314.          }
  315.       }
  316.       
  317.       [Bindable("loaderContextChanged")]
  318.       public function get loaderContext() : LoaderContext
  319.       {
  320.          return _loaderContext;
  321.       }
  322.       
  323.       private function getHorizontalAlignValue() : Number
  324.       {
  325.          var _loc1_:String = getStyle("horizontalAlign");
  326.          if(_loc1_ == "left")
  327.          {
  328.             return 0;
  329.          }
  330.          if(_loc1_ == "right")
  331.          {
  332.             return 1;
  333.          }
  334.          return 0.5;
  335.       }
  336.       
  337.       [Bindable("progress")]
  338.       public function get percentLoaded() : Number
  339.       {
  340.          var _loc1_:Number = isNaN(_bytesTotal) || _bytesTotal == 0 ? Number(0) : Number(100 * (_bytesLoaded / _bytesTotal));
  341.          if(isNaN(_loc1_))
  342.          {
  343.             _loc1_ = 0;
  344.          }
  345.          return _loc1_;
  346.       }
  347.       
  348.       private function contentLoaderInfo_unloadEventHandler(param1:Event) : void
  349.       {
  350.          dispatchEvent(param1);
  351.       }
  352.       
  353.       mx_internal function contentLoaderInfo_completeEventHandler(param1:Event) : void
  354.       {
  355.          if(LoaderInfo(param1.target).loader != mx_internal::contentHolder)
  356.          {
  357.             return;
  358.          }
  359.          dispatchEvent(param1);
  360.          contentLoaded();
  361.       }
  362.       
  363.       override public function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  364.       {
  365.          var sm:ISystemManager = null;
  366.          var styleProp:String = param1;
  367.          var recursive:Boolean = param2;
  368.          super.notifyStyleChangeInChildren(styleProp,recursive);
  369.          try
  370.          {
  371.             sm = content as ISystemManager;
  372.             if(sm != null)
  373.             {
  374.                Object(sm).notifyStyleChangeInChildren(styleProp,recursive);
  375.             }
  376.          }
  377.          catch(error:Error)
  378.          {
  379.          }
  380.       }
  381.       
  382.       [Bindable("autoLoadChanged")]
  383.       public function get autoLoad() : Boolean
  384.       {
  385.          return _autoLoad;
  386.       }
  387.       
  388.       public function set source(param1:Object) : void
  389.       {
  390.          if(_source != param1)
  391.          {
  392.             _source = param1;
  393.             contentChanged = true;
  394.             invalidateProperties();
  395.             invalidateSize();
  396.             invalidateDisplayList();
  397.             dispatchEvent(new Event("sourceChanged"));
  398.          }
  399.       }
  400.       
  401.       [Bindable("sourceChanged")]
  402.       public function get source() : Object
  403.       {
  404.          return _source;
  405.       }
  406.       
  407.       private function contentLoaderInfo_httpStatusEventHandler(param1:HTTPStatusEvent) : void
  408.       {
  409.          dispatchEvent(param1);
  410.       }
  411.       
  412.       public function set loaderContext(param1:LoaderContext) : void
  413.       {
  414.          _loaderContext = param1;
  415.          explicitLoaderContext = true;
  416.          dispatchEvent(new Event("loaderContextChanged"));
  417.       }
  418.       
  419.       private function get contentHolderWidth() : Number
  420.       {
  421.          var loaderInfo:LoaderInfo = null;
  422.          var content:IFlexDisplayObject = null;
  423.          var testContent:DisplayObject = null;
  424.          if(mx_internal::contentHolder is Loader)
  425.          {
  426.             loaderInfo = Loader(mx_internal::contentHolder).contentLoaderInfo;
  427.          }
  428.          if(loaderInfo)
  429.          {
  430.             if(loaderInfo.contentType == "application/x-shockwave-flash")
  431.             {
  432.                try
  433.                {
  434.                   content = Loader(mx_internal::contentHolder).content as IFlexDisplayObject;
  435.                   if(content)
  436.                   {
  437.                      return content.measuredWidth;
  438.                   }
  439.                }
  440.                catch(error:Error)
  441.                {
  442.                   return mx_internal::contentHolder.width;
  443.                }
  444.             }
  445.             else
  446.             {
  447.                try
  448.                {
  449.                   testContent = Loader(mx_internal::contentHolder).content;
  450.                }
  451.                catch(error:Error)
  452.                {
  453.                   return mx_internal::contentHolder.width;
  454.                }
  455.             }
  456.             return loaderInfo.width;
  457.          }
  458.          if(mx_internal::contentHolder is IUIComponent)
  459.          {
  460.             return IUIComponent(mx_internal::contentHolder).getExplicitOrMeasuredWidth();
  461.          }
  462.          if(mx_internal::contentHolder is IFlexDisplayObject)
  463.          {
  464.             return IFlexDisplayObject(mx_internal::contentHolder).measuredWidth;
  465.          }
  466.          return mx_internal::contentHolder.width;
  467.       }
  468.       
  469.       private function loadContent(param1:Object) : DisplayObject
  470.       {
  471.          var child:DisplayObject = null;
  472.          var cls:Class = null;
  473.          var url:String = null;
  474.          var byteArray:ByteArray = null;
  475.          var loader:Loader = null;
  476.          var lc:LoaderContext = null;
  477.          var rootURL:String = null;
  478.          var lastIndex:int = 0;
  479.          var message:String = null;
  480.          var classOrString:Object = param1;
  481.          if(classOrString is Class)
  482.          {
  483.             cls = Class(classOrString);
  484.          }
  485.          else if(classOrString is String)
  486.          {
  487.             try
  488.             {
  489.                cls = Class(systemManager.getDefinitionByName(String(classOrString)));
  490.             }
  491.             catch(e:Error)
  492.             {
  493.             }
  494.             url = String(classOrString);
  495.          }
  496.          else if(classOrString is ByteArray)
  497.          {
  498.             byteArray = ByteArray(classOrString);
  499.          }
  500.          else
  501.          {
  502.             url = classOrString.toString();
  503.          }
  504.          if(cls)
  505.          {
  506.             contentHolder = child = new cls();
  507.             addChild(child);
  508.             contentLoaded();
  509.          }
  510.          else if(classOrString is DisplayObject)
  511.          {
  512.             contentHolder = child = DisplayObject(classOrString);
  513.             addChild(child);
  514.             contentLoaded();
  515.          }
  516.          else if(byteArray)
  517.          {
  518.             loader = new FlexLoader();
  519.             child = loader;
  520.             addChild(child);
  521.             loader.contentLoaderInfo.addEventListener(Event.COMPLETE,mx_internal::contentLoaderInfo_completeEventHandler);
  522.             loader.contentLoaderInfo.addEventListener(Event.INIT,contentLoaderInfo_initEventHandler);
  523.             loader.contentLoaderInfo.addEventListener(Event.UNLOAD,contentLoaderInfo_unloadEventHandler);
  524.             loader.loadBytes(byteArray,loaderContext);
  525.          }
  526.          else
  527.          {
  528.             if(!url)
  529.             {
  530.                message = resourceManager.getString("controls","notLoadable",[source]);
  531.                throw new Error(message);
  532.             }
  533.             loader = new FlexLoader();
  534.             child = loader;
  535.             addChild(loader);
  536.             loader.contentLoaderInfo.addEventListener(Event.COMPLETE,mx_internal::contentLoaderInfo_completeEventHandler);
  537.             loader.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS,contentLoaderInfo_httpStatusEventHandler);
  538.             loader.contentLoaderInfo.addEventListener(Event.INIT,contentLoaderInfo_initEventHandler);
  539.             loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,contentLoaderInfo_ioErrorEventHandler);
  540.             loader.contentLoaderInfo.addEventListener(Event.OPEN,contentLoaderInfo_openEventHandler);
  541.             loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,contentLoaderInfo_progressEventHandler);
  542.             loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,contentLoaderInfo_securityErrorEventHandler);
  543.             loader.contentLoaderInfo.addEventListener(Event.UNLOAD,contentLoaderInfo_unloadEventHandler);
  544.             if(Capabilities.isDebugger == true && url.indexOf(".jpg") == -1 && LoaderUtil.normalizeURL(Application.application.systemManager.loaderInfo).indexOf("debug=true") > -1)
  545.             {
  546.                url += url.indexOf("?") > -1 ? "&debug=true" : "?debug=true";
  547.             }
  548.             if(!(url.indexOf(":") > -1 || url.indexOf("/") == 0 || url.indexOf("\\") == 0))
  549.             {
  550.                if(SystemManagerGlobals.bootstrapLoaderInfoURL != null && SystemManagerGlobals.bootstrapLoaderInfoURL != "")
  551.                {
  552.                   rootURL = SystemManagerGlobals.bootstrapLoaderInfoURL;
  553.                }
  554.                else if(root)
  555.                {
  556.                   rootURL = LoaderUtil.normalizeURL(root.loaderInfo);
  557.                }
  558.                else if(systemManager)
  559.                {
  560.                   rootURL = LoaderUtil.normalizeURL(DisplayObject(systemManager).loaderInfo);
  561.                }
  562.                if(rootURL)
  563.                {
  564.                   lastIndex = Math.max(rootURL.lastIndexOf("\\"),rootURL.lastIndexOf("/"));
  565.                   if(lastIndex != -1)
  566.                   {
  567.                      url = rootURL.substr(0,lastIndex + 1) + url;
  568.                   }
  569.                }
  570.             }
  571.             requestedURL = new URLRequest(url);
  572.             lc = loaderContext;
  573.             if(!lc)
  574.             {
  575.                lc = new LoaderContext();
  576.                _loaderContext = lc;
  577.                if(trustContent)
  578.                {
  579.                   lc.securityDomain = SecurityDomain.currentDomain;
  580.                }
  581.                else
  582.                {
  583.                   attemptingChildAppDomain = true;
  584.                   lc.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
  585.                }
  586.             }
  587.             loader.load(requestedURL,lc);
  588.          }
  589.          invalidateDisplayList();
  590.          return child;
  591.       }
  592.       
  593.       public function get contentWidth() : Number
  594.       {
  595.          return !!mx_internal::contentHolder ? Number(mx_internal::contentHolder.width) : Number(NaN);
  596.       }
  597.       
  598.       [Bindable("scaleContentChanged")]
  599.       public function get scaleContent() : Boolean
  600.       {
  601.          return _scaleContent;
  602.       }
  603.       
  604.       [Bindable("progress")]
  605.       public function get bytesLoaded() : Number
  606.       {
  607.          return _bytesLoaded;
  608.       }
  609.       
  610.       override protected function commitProperties() : void
  611.       {
  612.          super.commitProperties();
  613.          if(contentChanged)
  614.          {
  615.             contentChanged = false;
  616.             if(_autoLoad)
  617.             {
  618.                load(_source);
  619.             }
  620.          }
  621.       }
  622.       
  623.       private function contentLoaderInfo_securityErrorEventHandler(param1:SecurityErrorEvent) : void
  624.       {
  625.          var _loc2_:LoaderContext = null;
  626.          if(attemptingChildAppDomain)
  627.          {
  628.             attemptingChildAppDomain = false;
  629.             _loc2_ = new LoaderContext();
  630.             _loaderContext = _loc2_;
  631.             callLater(load);
  632.             return;
  633.          }
  634.          dispatchEvent(param1);
  635.       }
  636.       
  637.       public function load(param1:Object = null) : void
  638.       {
  639.          var imageData:Bitmap = null;
  640.          var url:Object = param1;
  641.          if(url)
  642.          {
  643.             _source = url;
  644.          }
  645.          if(mx_internal::contentHolder)
  646.          {
  647.             if(isContentLoaded)
  648.             {
  649.                if(mx_internal::contentHolder is Loader)
  650.                {
  651.                   try
  652.                   {
  653.                      if(Loader(mx_internal::contentHolder).content is Bitmap)
  654.                      {
  655.                         imageData = Bitmap(Loader(mx_internal::contentHolder).content);
  656.                         if(imageData.bitmapData)
  657.                         {
  658.                            imageData.bitmapData = null;
  659.                         }
  660.                      }
  661.                   }
  662.                   catch(error:Error)
  663.                   {
  664.                   }
  665.                   Loader(mx_internal::contentHolder).unload();
  666.                   if(!explicitLoaderContext)
  667.                   {
  668.                      _loaderContext = null;
  669.                   }
  670.                }
  671.                else if(mx_internal::contentHolder is Bitmap)
  672.                {
  673.                   imageData = Bitmap(mx_internal::contentHolder);
  674.                   if(imageData.bitmapData)
  675.                   {
  676.                      imageData.bitmapData = null;
  677.                   }
  678.                }
  679.             }
  680.             else if(mx_internal::contentHolder is Loader)
  681.             {
  682.                try
  683.                {
  684.                   Loader(mx_internal::contentHolder).close();
  685.                }
  686.                catch(error:Error)
  687.                {
  688.                }
  689.             }
  690.             try
  691.             {
  692.                if(mx_internal::contentHolder.parent == this)
  693.                {
  694.                   removeChild(mx_internal::contentHolder);
  695.                }
  696.             }
  697.             catch(error:Error)
  698.             {
  699.                try
  700.                {
  701.                   removeChild(mx_internal::contentHolder);
  702.                }
  703.                catch(error1:Error)
  704.                {
  705.                }
  706.             }
  707.             contentHolder = null;
  708.          }
  709.          isContentLoaded = false;
  710.          brokenImage = false;
  711.          if(!_source || _source == "")
  712.          {
  713.             return;
  714.          }
  715.          contentHolder = loadContent(_source);
  716.       }
  717.       
  718.       public function set autoLoad(param1:Boolean) : void
  719.       {
  720.          if(_autoLoad != param1)
  721.          {
  722.             _autoLoad = param1;
  723.             contentChanged = true;
  724.             invalidateProperties();
  725.             invalidateSize();
  726.             invalidateDisplayList();
  727.             dispatchEvent(new Event("autoLoadChanged"));
  728.          }
  729.       }
  730.       
  731.       private function contentLoaderInfo_initEventHandler(param1:Event) : void
  732.       {
  733.          dispatchEvent(param1);
  734.       }
  735.       
  736.       override protected function measure() : void
  737.       {
  738.          var _loc1_:Number = NaN;
  739.          var _loc2_:Number = NaN;
  740.          super.measure();
  741.          if(isContentLoaded)
  742.          {
  743.             _loc1_ = mx_internal::contentHolder.scaleX;
  744.             _loc2_ = mx_internal::contentHolder.scaleY;
  745.             mx_internal::contentHolder.scaleX = 1;
  746.             mx_internal::contentHolder.scaleY = 1;
  747.             measuredWidth = contentHolderWidth;
  748.             measuredHeight = contentHolderHeight;
  749.             mx_internal::contentHolder.scaleX = _loc1_;
  750.             mx_internal::contentHolder.scaleY = _loc2_;
  751.          }
  752.          else if(!_source || _source == "")
  753.          {
  754.             measuredWidth = 0;
  755.             measuredHeight = 0;
  756.          }
  757.       }
  758.       
  759.       private function doScaleLoader() : void
  760.       {
  761.          if(!isContentLoaded)
  762.          {
  763.             return;
  764.          }
  765.          unScaleContent();
  766.          var _loc1_:Number = unscaledWidth;
  767.          var _loc2_:Number = unscaledHeight;
  768.          if(contentHolderWidth > _loc1_ || contentHolderHeight > _loc2_)
  769.          {
  770.             mx_internal::contentHolder.scrollRect = new Rectangle(0,0,_loc1_,_loc2_);
  771.          }
  772.          else
  773.          {
  774.             mx_internal::contentHolder.scrollRect = null;
  775.          }
  776.          mx_internal::contentHolder.x = (_loc1_ - contentHolderWidth) * getHorizontalAlignValue();
  777.          mx_internal::contentHolder.y = (_loc2_ - contentHolderHeight) * getVerticalAlignValue();
  778.       }
  779.       
  780.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  781.       {
  782.          var _loc3_:Class = null;
  783.          super.updateDisplayList(param1,param2);
  784.          if(contentChanged)
  785.          {
  786.             contentChanged = false;
  787.             if(_autoLoad)
  788.             {
  789.                load(_source);
  790.             }
  791.          }
  792.          if(isContentLoaded)
  793.          {
  794.             if(_scaleContent && !brokenImage)
  795.             {
  796.                doScaleContent();
  797.             }
  798.             else
  799.             {
  800.                doScaleLoader();
  801.             }
  802.             scaleContentChanged = false;
  803.          }
  804.          if(brokenImage && !brokenImageBorder)
  805.          {
  806.             _loc3_ = getStyle("brokenImageBorderSkin");
  807.             if(_loc3_)
  808.             {
  809.                brokenImageBorder = IFlexDisplayObject(new _loc3_());
  810.                if(brokenImageBorder is ISimpleStyleClient)
  811.                {
  812.                   ISimpleStyleClient(brokenImageBorder).styleName = this;
  813.                }
  814.                addChild(DisplayObject(brokenImageBorder));
  815.             }
  816.          }
  817.          else if(!brokenImage && brokenImageBorder)
  818.          {
  819.             removeChild(DisplayObject(brokenImageBorder));
  820.             brokenImageBorder = null;
  821.          }
  822.          if(brokenImageBorder)
  823.          {
  824.             brokenImageBorder.setActualSize(param1,param2);
  825.          }
  826.       }
  827.       
  828.       private function getVerticalAlignValue() : Number
  829.       {
  830.          var _loc1_:String = getStyle("verticalAlign");
  831.          if(_loc1_ == "top")
  832.          {
  833.             return 0;
  834.          }
  835.          if(_loc1_ == "bottom")
  836.          {
  837.             return 1;
  838.          }
  839.          return 0.5;
  840.       }
  841.       
  842.       public function get content() : DisplayObject
  843.       {
  844.          if(mx_internal::contentHolder is Loader)
  845.          {
  846.             return Loader(mx_internal::contentHolder).content;
  847.          }
  848.          return mx_internal::contentHolder;
  849.       }
  850.       
  851.       private function doScaleContent() : void
  852.       {
  853.          var interiorWidth:Number = NaN;
  854.          var interiorHeight:Number = NaN;
  855.          var contentWidth:Number = NaN;
  856.          var contentHeight:Number = NaN;
  857.          var x:Number = NaN;
  858.          var y:Number = NaN;
  859.          var newXScale:Number = NaN;
  860.          var newYScale:Number = NaN;
  861.          var scale:Number = NaN;
  862.          var w:Number = NaN;
  863.          var h:Number = NaN;
  864.          var holder:Loader = null;
  865.          var lInfo:LoaderInfo = null;
  866.          if(!isContentLoaded)
  867.          {
  868.             return;
  869.          }
  870.          if(!resizableContent || maintainAspectRatio && !flexContent)
  871.          {
  872.             unScaleContent();
  873.             interiorWidth = unscaledWidth;
  874.             interiorHeight = unscaledHeight;
  875.             contentWidth = contentHolderWidth;
  876.             contentHeight = contentHolderHeight;
  877.             x = 0;
  878.             y = 0;
  879.             newXScale = contentWidth == 0 ? Number(1) : Number(interiorWidth / contentWidth);
  880.             newYScale = contentHeight == 0 ? Number(1) : Number(interiorHeight / contentHeight);
  881.             if(_maintainAspectRatio)
  882.             {
  883.                if(newXScale > newYScale)
  884.                {
  885.                   x = Math.floor((interiorWidth - contentWidth * newYScale) * getHorizontalAlignValue());
  886.                   scale = newYScale;
  887.                }
  888.                else
  889.                {
  890.                   y = Math.floor((interiorHeight - contentHeight * newXScale) * getVerticalAlignValue());
  891.                   scale = newXScale;
  892.                }
  893.                mx_internal::contentHolder.scaleX = scale;
  894.                mx_internal::contentHolder.scaleY = scale;
  895.             }
  896.             else
  897.             {
  898.                mx_internal::contentHolder.scaleX = newXScale;
  899.                mx_internal::contentHolder.scaleY = newYScale;
  900.             }
  901.             mx_internal::contentHolder.x = x;
  902.             mx_internal::contentHolder.y = y;
  903.          }
  904.          else
  905.          {
  906.             mx_internal::contentHolder.x = 0;
  907.             mx_internal::contentHolder.y = 0;
  908.             w = unscaledWidth;
  909.             h = unscaledHeight;
  910.             if(mx_internal::contentHolder is Loader)
  911.             {
  912.                holder = Loader(mx_internal::contentHolder);
  913.                try
  914.                {
  915.                   if(holder.content.width > 0)
  916.                   {
  917.                      if(holder.content is IFlexDisplayObject)
  918.                      {
  919.                         IFlexDisplayObject(holder.content).setActualSize(w,h);
  920.                      }
  921.                      else
  922.                      {
  923.                         lInfo = holder.contentLoaderInfo;
  924.                         if(lInfo)
  925.                         {
  926.                            mx_internal::contentHolder.scaleX = w / lInfo.width;
  927.                            mx_internal::contentHolder.scaleY = h / lInfo.height;
  928.                         }
  929.                         else
  930.                         {
  931.                            mx_internal::contentHolder.width = w;
  932.                            mx_internal::contentHolder.height = h;
  933.                         }
  934.                      }
  935.                   }
  936.                   else if(!(holder.content is IFlexDisplayObject))
  937.                   {
  938.                      mx_internal::contentHolder.width = w;
  939.                      mx_internal::contentHolder.height = h;
  940.                   }
  941.                }
  942.                catch(error:Error)
  943.                {
  944.                   mx_internal::contentHolder.width = w;
  945.                   mx_internal::contentHolder.height = h;
  946.                }
  947.             }
  948.             else
  949.             {
  950.                mx_internal::contentHolder.width = w;
  951.                mx_internal::contentHolder.height = h;
  952.             }
  953.          }
  954.       }
  955.       
  956.       private function contentLoaderInfo_ioErrorEventHandler(param1:IOErrorEvent) : void
  957.       {
  958.          source = getStyle("brokenImageSkin");
  959.          load();
  960.          contentChanged = false;
  961.          brokenImage = true;
  962.          if(hasEventListener(param1.type))
  963.          {
  964.             dispatchEvent(param1);
  965.          }
  966.       }
  967.    }
  968. }
  969.